Journal of Open Source Software

Background: Reproducible taxonomic collapsing and geological-timescale annotation of time-calibrated phylogenetic trees in R often require coordination among several packages and repeated code for label parsing, clade validation, plotting, and export. Workflow-managed analyses additionally benefit from non-interactive configuration, predictable diagnostics, and machine-readable exit status. Results: We present Rclade, an R package that consolidates the multi-package coordination required for taxonomic collapsing into a streamlined, single-function interface. Rclade provides (1) custom ggproto objects (GeomPolygonStraight/GeomSegmentStraight) that bypass coord_munch() interpolation to achieve straight-edge rendering of collapsed triangles in circular layouts; (2) automatic detection and parsing of four taxonomic-label formats (GTDB, Silva, NCBI, embedded) plus user-supplied custom regex, with explicit input-validation contracts and parsing-accuracy evaluation on real and derived test sets; and (3) workflow embeddability through YAML configuration, library-mode APIs, and standard Unix exit codes. Benchmarks on synthetic and real datasets (200-10,000 synthetic tips and real reference trees up to 10,122 tips; 5 replicates at every scale under a unified fully rendered measurement protocol) show that the full-pipeline overhead is modest for interactive use (median {approx}0.87 s in-session rendering and {approx}8.4 s process-level wall-clock at 10,000 tips). Conclusions: Rclade is a convenience layer over the ggtree/deeptime ecosystem that reduces boilerplate while adding targeted technical improvements for circular-layout rendering and format heterogeneity management.

Summarybcftools is the standard toolkit for handling VCF and BCF variant files, but it processes records on a single core; its --threads option speeds up only compression of the output, not the work done on variant records. Processing large call sets is therefore slow, and users often divide the genome and reassemble the results by hand. We present pbcftools, a Perl wrapper that does this automatically: it splits the genome into chunks, runs an ordinary bcftools command on each in parallel, and reassembles the outputs by a method suited to the data type. Across Linux servers, Windows/WSL2 workstations and Apple laptops, with bcftools 1.21 to 1.24, parallel output was identical to serial output for every command tested. On 1000 Genomes Phase 3 data, operations writing compressed VCF ran 10.8 to 21.1 times faster with 32 cores and up to 35.4 times with 64, those writing text 3.7 to 12.8 times, and merging 100 VCF files 19.2 times. pbcftools also runs on LSF and Slurm clusters. Availability and implementationpbcftools is written in Perl (>= 5.16) and requires bcftools; local parallel execution also requires Perl module Parallel::ForkManager. It is released under the MIT license at https://github.com/zhangge-uc/pbcftools (DOI: 10.5281/zenodo.21780361).

Proteins and their associated complexes often adopt multiple conformations, with the transitions between these states playing a critical role in biological function. However, the resulting structural heterogeneity can be challenging to visualize and communicate, often requiring manual inspection and time-consuming annotation of biomolecular structures. To address this, we developed ResiRuler, a local, browser-based tool that uses inter-residue distance measurements to quickly quantify atomic displacements and map changes in internal geometry across ensembles of related protein structures. By converting structural differences into residue-pair distance changes, ResiRuler enables rapid identification of regions undergoing coordinated motion, local rearrangement, or large-scale conformational change. The resulting visualizations can be exported as scripts for PyMOL and ChimeraX, allowing users to explore conformational differences and generate publication-quality molecular figures in their preferred visualization environment. Using atomic models in Macromolecular Crystallographic Information File (mmCIF) file format, ResiRuler aligns multiple structures and measures structural variation across models facilitating visualization and presentation of these differences. This allows for rapid visualization of which regions of proteins change among ensembles of structures. The program is available for download at https://github.com/tbaker67/ResiRuler on macOS and Linux operating systems.

In many bioinformatic data analysis projects, it is convenient to visualize plots and results through an interactive web app or dashboard. These interactive reports can then be shared with customers, collaborators, or the general public. Publishing and sharing these apps is not straightforward, becoming especially cumbersome when the number of projects and customers start growing. Docker containers offer a convenient way to package, distribute, and run interactive web apps, and their use is already widespread in the bioinformatics community. We developed Kiosc to simplify the orchestration of containerized web apps, organize them into projects, and regulate access control. We implemented it as a web server based on the Django framework, with a user- and admin-friendly interface as well as a REST API for programmatic tasks. Users can select Docker containers packaging apps like Plotly Dash, Shiny, or Quarto, and configure them to display the results of their analysis. Kiosc runs the containers with the appropriate network configuration and acts as a proxy to the web services running inside the containers. We have been maintaining a Kiosc instance for more than 5 years, serving 321 containers in 150 projects across multiple institutions. In this article, we introduce the main functionality in Kiosc and describe four use-cases that show how Kiosc can prove helpful to the broader bioinformatics community, such as configuring and running web apps for the interactive visualization of workflow results, and publishing companion apps for scientific articles. Kiosc is a self-hosted platform for publishing web apps, which doesn't require significant expertise in either Docker or network administration to be deployed. It provides a similar service to Kubernetes, but with a convenient web interface and much lower administration overhead.

Structural variants (SVs) are large-scale genomic variants, which can disrupt important functional and regulatory elements, leading to genomic disorders in humans and playing important roles in domestication, disease resistance, and traits in plants. SVs are generated across populations of individuals and used for association studies, consisting of large datasets with thousands of genomic loci. Visualization of these SVs aids in understanding their genomic distribution, identifying patterns across affected or phenotypic groups, and assessing their proximity to other genomic regions of interest. A variety of tools exist for visualizing SVs, including linear genome browsers and graph-based methods; however, many do not offer intuitive or scalable representations of SVs across large populations. To address this, we present SVPopEx, an interactive tool for population-wide visualization and exploration of SVs. SVPopEx provides a unique and intuitive representation for insertions, deletions, inversions, duplications, and translocations in a linear genome-style browser. Novel features were developed to support comparisons across genomes within user-defined regions, including rendering SVs based on one or more samples and visualizing haplotypes. Use of the tool is demonstrated with SV datasets from Schistosoma mansoni and Lens culinaris. A task-based evaluation was conducted using SVPopEx and two other linear genome browsers, which demonstrated that SVPopEx excelled in (1) providing a clear representation of the SVs present and (2) supporting comparisons across genomes.

Motivation: Interactive tools that let non-programmers explore an analyzed single-cell dataset, its embeddings, gene expression, cell metadata, and marker genes, have become standard laboratory infrastructure. Every actively maintained tool in this space (ShinyCell, ScRDAVis, sCIRCLE, scViewer) is built on R Shiny and requires a Seurat object as input. Laboratories whose primary analysis pipeline is Python/scanpy, the dominant framework for single-cell RNA-seq, spatial, and multi-omic analysis, therefore have no lightweight, language-native option that pairs a shareable web-based viewer with a scriptable Python API: sharing a scanpy result means either exporting to Seurat first or handing over a notebook that only a programmer can run. Results: We present scPyviewer, a web-based viewer that ingests AnnData objects directly and reproduces the core interaction patterns of the incumbent R Shiny tools without leaving the Python stack. In a feature-parity audit against three actively maintained R Shiny incumbents, scPyviewer matches or exceeds every baseline capability (7/7); among these, it uniquely offers native AnnData ingestion with no Seurat conversion, and cross-dataset comparison over shared genes and matched cell-type composition. Benchmarked head-to-head against the R/Seurat rendering substrate the incumbents are built on, identical operations, identical data, across three datasets spanning 22,315 to roughly 313,000 cells, scPyviewer renders every core view faster at every scale tested (up to 3.6x on a single view) and at a fraction of the memory (5.2x lower on the smallest dataset). At the largest scale tested, the gap becomes categorical rather than incremental: scPyviewer completes every view on a 313,000-cell dataset while the Seurat substrate exhausts an 8 GB memory budget and fails outright. Beyond the interactive app, scPyviewer installs via pip or conda and exposes a public Python API that returns Matplotlib figures and pandas tables for scripted, publication-ready output. Availability and implementation: scPyviewer is implemented in Python 3.11 (scanpy 1.11.5, anndata 0.12.19, streamlit 1.59.2, plotly 6.9.0) and distributed with a one-command reproduction interface that installs pinned dependencies, regenerates the benchmark and all figures, and launches the interactive app. Source code is available at https://github.com/xuan13hao/scPyviewer.git.

Scientific agents can produce plausible answers while remaining unable to establish whether the computation behind an answer is executable, recoverable, or reproducible. We present BloClaw, an AI4S workstation built around a simple principle: a scientific agent should know what it can do, show how it did it, and state what remains unvalidated. Each capability declares an execution state, input constraints, dependencies, expected outputs, and scientific limitations. Natural-language requests are translated into structured tasks, validated against this registry, executed through scientific tools, and recorded in a provenance-aware Living Lab Notebook. The system is designed to detect invalid inputs, failed tool calls, missing dependencies, and remote timeouts, and to route them to repair, retry, or escalation. The implemented and tested scope comprises RDKit-based molecular property and rule screening, protein structure analysis, docking-pose inspection, 3D visualization, and structured reporting. We demonstrate the workflow on a PubChem-retrieved osimertinib structure and a supplied 6LU7 docking artifact: the former yields deterministic descriptors (molecular weight 499.619 Da, cLogP 4.5098, TPSA 87.55 A^2), while the latter contains 2,387 protein ATOM records, 309 residues, and nine pose records. These examples are workflow demonstrations, not efficacy or affinity studies. Beyond retrospective prediction, the manuscript specifies a prior-minimized constructive mode in which a desired function is compiled into explicit physical, chemical, and systems constraints, candidate mechanisms are simulated, and observations are reintroduced for calibration and falsification; this is a proposed extension rather than a result of the present case studies. We describe an evaluation protocol that compares BloClaw with a standard single-agent workflow and fixed-script execution using task completion, scientific correctness, recovery success, provenance completeness, reproducibility, human review time, latency, and cost. This manuscript reports the system design, verified capability boundary, deterministic software artifacts, and a reproducible evaluation protocol; it does not claim benchmark improvements before those experiments are run. BloClaw is an execution and accountability layer for AI-assisted research, complementing expert review and experimental validation rather than replacing them.

EegFun.jl is an open-source package for electroencephalography (EEG) analysis implemented in the Julia programming language. EegFun.jl provides a flexible framework for EEG research, covering data import from standard file formats, filtering and re-referencing, Independent Component Analysis (ICA) for artifact detection/correction, epoch extraction, and ERP averaging and visualisation. The Julia language provides the readability of a high-level scripting environment together with execution speeds comparable to compiled code. EegFun.jl combines interactive data visualization with high-performance execution, making large-scale analyses both efficient and easy. Here, we provide a brief overview and introductory tutorial of the core stages of the EEG analysis workflow to illustrate the packages capabilities. The package is freely available under the MIT license.

MotivationAnalysing and concatenating phage annotation is time-consuming. Further, the output of phage annotation tools cannot be directly submitted to public repositories. To deal with these issues, we developed PhaGAMeToo. This command-line workflow for Linux integrates the functional annotations of two major viral annotation tools (Pharokka and VIBRANT), enabling faster and more accurate functional annotation. Furthermore, the workflow provides merged annotations as submission-ready GenBank files. ResultsPhaGAMeToo uses three steps to generate submission-ready GenBank files. The user uses the reoriented viral genomes as inputs for Pharokka and VIBRANT. Pharokka and VIBRANT-generated files are parsed through the PhaGAMeToo workflow to produce a merged GenBank file. Further, PhaGAMeToo also enables the use of BLASTP to annotate hypothetical proteins not identified by Pharokka and VIBRANT. It then merges the results into a submission-ready GenBank file(s). We tested PhaGAMeToo in three different Use Cases. We analysed reference and uncultivated viral genomes manually curated or directly recovered using MuDoGeR in our Use Cases. In the Use Case 1, we analysed four different NCBI reference genomes. In the Use Cases 2 and 3, we analysed seven recently described huge phage genomes and 56 uncultivated viral genomes recovered from 30 soil metagenomes, respectively. Availability and implementationThe source code, documentation, and installation instructions for PhaGAMeToo are available at https://github.com/NFDI4Microbiota/PhaGAMeToo ContactRene.Kallies@uba.de; ebrardemircioglu25@hacettepe.edu.tr Supplementary informationSupplementary data will be made available upon publication.

Summary: Prot2Surf is a software tool designed for the characterization and prediction of protein association to surfaces. In this application note, Prot2Surf was tested using catalytic domains of the lytic polysaccharide monooxygenases (LPMOs), interacting with native surfaces. The results show that the software can efficiently analyze key binding features, including protein-surface distances, distances between catalytically reactive atoms, and the orientation angle between surface chains and the protein. These features are essential for distinguishing productive binding poses in these protein-surface systems and for understanding interaction patterns that provide guidance on protein engineering. Prot2Surf performs these analyses within seconds to a few minutes, providing a fast and accessible framework to post-process and characterize protein-surface encounter complexes. Availability and implementation: Prot2Surf, which is written in Fortran90, is documented and freely available as open source on GitHub: https://github.com/TUNNELING-GROUP/Prot2Surf. In order to run Prot2Surf, users should also install the SDA software package which is freely available at https://www.h-its.org/downloads/sda7/.

Network-based analyses of molecular interactions are useful for interpreting high-throughput omics data and identifying therapeutic targets. Cytoscape is the standard platform for these tasks, but users face a trade-off between accessible graphical workflows that are difficult to document and reproducible automation in Python or R that requires programming expertise. General-purpose coding assistants can generate Cytoscape Automation scripts, but remain external to Cytoscape. We present CyChat, a Cytoscape Desktop app that integrates a chat interface and a large language model (LLM) agent into the application. CyChat translates natural language into executable Cytoscape Automation workflows, runs generated Python code, and exports chat sessions with executed code as standalone Jupyter notebooks. To reduce setup barriers, CyChat includes an embedded Python runtime and supports both cloud-based and locally hosted LLMs. CyChat was evaluated across ten Cytoscape workflows using seven LLM providers, each represented by one LLM. The strongest configuration achieves a pass rate above 99%. In a qualitative evaluation based on a published network visualization, CyChat completes the task in 1.5-5 minutes, compared with 15-20 minutes for manual GUI workflows by computational biologists. CyChat is available through the Cytoscape App Store at https://apps.cytoscape.org/apps/cychat.

Drosophila connectomic datasets provide increasingly comprehensive maps of neuronal morphology and synaptic connectivity, offering an unprecedented opportunity to explore the structural organization of its neural circuits. This calls for designing automated tools to interact with connectomic datasets at scale for efficiently exploring structural features embedded in the vast amount of data. Yet the central challenge remains the understanding of the functional logic of neural circuits. In order to understand how elements of the functional logic may emerge from this structural organization, it is critical to (i) characterize the objects in the natural environment in which brain circuits operate, and (ii) formulate how brain circuits represent and process the defined objects in the natural environment. To develop and demonstrate a methodology for these requirements, we focus on the Drosophila looming-evoked escape pathway. We modeled the trajectory of looming objects that are on a collision course (direct-hits) or pass-by the fly (near-misses): their projected images on the retina can be characterized by the solid angle (angular size) and elevation. We then analyzed the pathway's morphology across the OpticLobe, Hemibrain, and FlyWire connectome datasets. By abstracting their sub-neuronal structure and retinotopic organization, we constructed an executable circuit model that maps each structural element to a processing block. We demonstrate that this model separates direct hits from near misses well before the angular size could tell them apart. To accelerate the connectomic analysis step, we developed a Python toolset with an agentic, code-free workspace interface called NeuroGraphBench (NGB). NGB provides four composable morphology-analysis primitives and an AI agent that composes them to interactively respond to natural-language queries aided by visualization on an interactive 3D canvas. Thus, NGB automates tedious and repetitive tasks to enable faster and scalable connectomic exploration, keeping human reasoning, instead of writing code, at the center of an open-ended research inquiry.

SummaryIntegrating spatial multi-omics data requires coordinated preprocessing, cross-modality alignment and feature registration across modalities that differ in file format, coordinate system and spatial resolution. No existing tool addresses this pipeline end-to-end from raw experimental files till aligned data object. We present FOCUS, an open-source Python package that takes raw data from spatial transcriptomics, mass spectrometry imaging, Raman spectroscopy imaging and brightfield or fluorescence microscopy through modality-specific preprocessing, interactive spatial alignment and resolution-matching registration to a unified MuData object, driven by a single configuration file. Its modular, registry-based architecture allows straightforward extension to additional modalities. FOCUS is accessible via a command-line interface, a browser-based GUI and a Python API. Availability and implementationFOCUS is implemented in Python 3.11, with a browser-based GUI built on a Vue.js 3 frontend served by a Flask backend. Source code, documentation and container recipes are available at https://github.com/sifrimlab/FOCUS; a versioned release is archived on Zenodo (10.5281/zenodo.21700038). Outputs use the AnnData and MuData formats and are directly compatible with the scverse ecosystem.

Achieving FAIR compliance requires both standardized metadata and infrastructure for data deposition, yet in practice a large fraction of sequencing studies is still published without the persistent, standards-compliant metadata that reuse depends on. Collecting MIxS-compliant metadata is complex: environment-specific checklists can contain hundreds of fields, and the effort is magnified when metadata is assembled retrospectively at publication time rather than captured throughout the project. We developed SeqDesk, an open-source data management system for sequencing facilities that is designed so that FAIR-compliant public data is produced as the natural output of routine operations. Its current scope is microbial sequencing data, covering metagenomes as well as isolate genomes, for which it supports the corresponding MIxS checklists. SeqDesk gives a sequencing facility a configurable order-and-tracking system for sequencing projects, captures and validates MIxS-compliant metadata aligned with ENA checklists at project initiation, runs bioinformatics analyses through Nextflow pipelines, and brokers submission to the European Nucleotide Archive, all within the institutions own infrastructure. By embedding standards-compliant metadata capture into the sequencing-facility workflow rather than bolting it on at submission, SeqDesk shortens the path from sample to reusable public data. The underlying checklist model is generic, so support can be extended to further data types and metadata standards beyond the microbial domain. SeqDesk is free and open source under the Apache 2.0 licence and available at https://seqdesk.org, with a live demonstration at https://seqdesk.org/#demo.

Structural variants (SVs) are a diverse group of genetic variants defined by a minimum size of 50 base pairs. SVs account for the majority of all variant bases in a persons genome and are commonly implicated in inherited disease and cancer. However, SV analysis is complex due to their wide variation in type and size, degree of polymorphism, involvement of repetitive sequences, and the myriad ways they may elicit a functional impact, as well as technical factors like imprecise breakpoint detection, and alternative representations of the same event. Despite recent advances in the detection and characterisation of SVs, it remains difficult to assess them beyond basic annotations and comparisons. Here we introduce SVlog, a transparent and extensible meta-programming framework for SV analysis. With the logic programming language Souffle as its engine, SVlog provides a declarative ontology describing relationships among SVs, genes and other genomic elements. Genome annotations and SV datasets - both user-provided and public reference data - are converted into relational facts, to which SVlog applies logical rules that define predicates. Predicates are specific, transparent and deterministic, yet fully flexible and composable, enabling detailed evaluation of SVs without relying on stochastic "black box" approaches. To showcase SVlog, we have developed a ready-made predicate library for SV annotation, comparison and prioritisation in the context of rare inherited disease. Despite its compact codebase, SVlog evaluates more than 50 input predicates to generate over 70 informative output predicates. It synthesises evidence from population and clinical genomic databases, and applies a tiered filtering strategy to identify candidate pathogenic SVs in patients with inherited disease. By focusing on explainability and modularity, SVlog offers a fast, reliable library for SV analysis and is a powerful deterministic alternative to traditional bioinformatics pipelines for clinical variant curation.

FigTree is a long-standing phylogenetic tree viewer, but its GUI-centered workflow does not itself provide a versioned, batch-replayable record of styling operations. We present FigTreeKit, a Python package that serializes a supported subset of FigTree 1.4.4 annotations (!hilight, !color, and !font), audits taxonomy mappings before topology-gated clade collapse, retains selected BEAST-style metadata in the tested fixtures, and invokes a patched FigTree renderer for headless PNG, PDF, and SVG output. Across 60 independently generated balanced trees with 50-10,000 taxa (10 trees per size, each timed 10 times as technical replicates), the tree-level log-log slope of export time was 0.96 (95% confidence interval [CI], 0.91-1.01), which is compatible with approximately linear scaling over the tested range but does not prove it. The 189,801-taxon GTDB R232 bacterial reference tree was parsed and exported as a large-data scalability demonstration. On the 10,122-taxon GTDB R232 archaeal reference tree, the scripted workflow assessed 179 order-level groups; 142 multi-tip groups produced non-trivial collapses, whereas 37 singleton groups did not alter the display. The software is accompanied by 796 passing tests, a golden conformance corpus that includes acceptance tests against the bundled FigTree JAR, deterministic scenario-based topology checks, and an overall statement coverage of 81%, reported as a descriptive engineering metric. FigTreeKit is released under the GPL-2.0-or-later license as the figtreekit package on PyPI, with source code, documentation, and benchmark data archived on Zenodo.

Motivation: The actual interface pTM score (actifpTM) is a modified version of the ipTM score that limits the calculation to only those residues at the interface. Whilst actifpTM provides an effective interface quality score, a limiting factor is that it makes use of the predicted aligned error (PAE) with probabilities, information that is generated during a ColabFold run, but not output by the package or other model prediction software. The consequent inability to generate actifpTM scores for the results of software such as AlphaFold 2 or AlphaFold 3 has limited its adoption. With reactifpTM we address this problem by providing a standalone tool that can be run on the standard outputs of most model prediction packages. Results: Using the same underlying principles as actifpTM, reactifpTM has been developed to use standard output files from model prediction software (a model and corresponding PAE) to perform an actifpTM-like calculation. ColabFold models were generated for a dataset of 1079 known interfaces in the PDB. A strong correlation was shown between actifpTM and reactifpTM for this dataset. Availability and implementation: reactifpTM is coded in Python. All scripts and associated documentation are available from https://github.com/hlasimpk/reactifptm or https://pypi.org/project/reactifptm.

Genomic Foundation Models (GFMs) are increasingly used for large-scale sequence analysis and generation. Compared with frontier language models, GFMs are typically smaller and frequently operate on long genomic sequences, with evaluation often requiring preservation of biologically meaningful structure and sequence-level relationships. Although low-precision post-training quantization (PTQ) has shown substantial memory and throughput benefits for general-purpose language models, it remains unclear whether these benefits transfer to GFMs given their distinct model scales, sequence characteristics, and evaluation requirements. We present an empirical case study of FP8 post-training quantization applied to GenomeOcean, a computationally efficient genomic foundation model with strong reported performance across diverse genomics tasks [Zhou et al., 2025]. Its range of model scales, from 100M to 4B parameters, provides a useful setting for examining how quantization effects vary with model size. We evaluate FP8 across two primary GFM inference regimes--embedding extraction and autoregressive generation--and assess its impact along two dimensions: biological fidelity relative to BF16 baselines and system-level efficiency in terms of throughput, memory usage, and energy efficiency. We find that FP8 largely preserves biological fidelity across the evaluated scales and inference regimes, while reducing GPU memory footprint at 4B scale and improving energy efficiency during autoregressive generation. However, realized throughput gains remain substantially below FP8s theoretical 2x hardware ceiling, with a best-case improvement of 19.3% in autoregressive generation and benefits varying strongly by model scale and workload. Autoregressive generation shows the clearest gains, driven largely by KV-cache compression, whereas embedding extraction provides limited or negative throughput benefits at smaller model scales. We attribute this theory-practice gap to the interaction of model-scale effects, memory-system bottlenecks, and software-stack limitations. These findings highlight the need for workload-specific empirical evaluation before adopting low-precision inference in scientific foundation models. Code availabilityhttps://github.com/jgi-genomeocean/genomeocean_efficiency

Surface phenotyping underpins plant science, preclinical animal research and entomology, yet across all three the measurement is almost always a photograph, which records a projection and not the surface itself. Here we present the Gentschinator3000, an open structured-light platform that brings high-end metric surface measurement within reach of laboratories with no optics expertise, combining documented open hardware, open reconstruction software and analysis workflows for under 4000 Euro in components. It resolves a planar reference to 45 m local flatness, registers full rotations to a loop closure of 156 m, and performs stably across acquisition ranges that we define. Applying one workflow to a leaf before and after desiccation, to murine anatomy and to a spread lepidopteran, we find that projection underestimates surface area by 11 to 41 %. That error grows with the condition under study, with the evaluation scale and with the direction of view, so it can confound phenotype comparisons dramatically. In murine limbs a 15-degree change of viewing direction shifts a projected inter-segment angle by up to 23.2 degrees, while the three-dimensional angle does not move. Projection geometry can therefore contribute as much to a measured phenotype as the biology it is meant to quantify.

Genome-wide association studies (GWAS) play a crucial role in unraveling the genetic foundations of complex traits in plants but are also hampered by the application of heterogeneous tools, incompatible file formats and disparate computational environments. Existing GWAS frameworks are often restricted to a single linear reference genome, limiting the capacity for the analysis of structural variations and presence/absence variations (PAV) within plant populations. These issues pose obstacles to reproducibility, scalability, and comprehensive investigations. Here, we present PlantOmicsGWAS, an open-source Python framework for reproducible plant genome-wide association analysis and genomic prediction. It integrates reference indexing, FASTQ quality control, alignment, variant calling, VCF normalization, PLINK conversion, linkage disequilibrium analysis, population-structure estimation, association testing, marker scoring, genomic prediction, and visualization within a unified Linux and HPC workflow. The framework supports conventional linear-reference analyses and includes an optional pangenome-oriented module for working with multiple assemblies and graph-derived variation. Using a Vitis benchmark dataset containing 120 accessions and 118,247 graph-derived variants, PlantOmicsGWAS reduced manual workflow fragmentation and generated standardized association outputs. This tool provides a modular and extensible platform for plant GWAS and pan-GWAS workflows while retaining compatibility with established command-line tools and common genotype formats. The GWAS workflow described herein is adaptable to a range of sequencing methods and plant genomes, bridging research on crop related issues across various biological levels, from the individual organism to entire populations. PlantOmicsGWAS implements Bayesian sparse linear mixed modeling (BSLMM) through GEMMA for multi-trait association discovery, while also supporting FaST-LMM, regression-based approaches, and machine-learning algorithms (Random Forest, XGBoost) as benchmarking alternatives. The PlantOmicsGWAS, a versatile toolkit is available at GitHub https://github.com/plantomicsgwas1-boop/PlantOmicsGwas_V1 and on Linux and HPC platform (https://pypi.org/project/PlantOmicsGwas/1.0.2/).